home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 1 / PC Actual CD 01.iso / f1 / cimb.arj / MEMORIA.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-07  |  8.9 KB  |  390 lines
  1. /*==============================================================================
  2.  
  3. FICHERO: MEMORIA.C
  4.  
  5. AUTOR: ANTONIO LADESA JURADO
  6.  
  7. FECHA: 24/6/94
  8.  
  9. DESCRIPCION:
  10.  
  11.     Fichero que contiene las estructuras, constantes, variables y funciones
  12.     internas y externas para la gestión de memoria VMS, XMS y EMS.
  13.  
  14. ==============================================================================*/
  15.  
  16.  
  17. /*---- MODULOS USADOS --------------------------------------------------------*/
  18.  
  19. #include <stdlib.h>
  20. #include <stdio.h>
  21. #include <alloc.h>
  22. #include <string.h>
  23.  
  24. #include "global.h"
  25. #include "memoria.h"
  26. #include "error.h"
  27.  
  28. /*---- VARIABLES LOCALES -----------------------------------------------------*/
  29.  
  30.     /* tipo de memoria actual */
  31. static int MEMTipo;
  32.  
  33.     /* direccion del marco de pagina para EMS */
  34. static char *EMSmarco_pagina;
  35.  
  36. /*---- CODIFICACION DE LAS FUNCIONES OFRECIDAS -------------------------------*/
  37.  
  38.  
  39. /*---- FUNCION: extern int MEMSeleccionar(int tipo) ----------------------------
  40.  
  41.     Descripción:
  42.  
  43.         Esta función selecciona el tipo de memoria a usar por la aplicación
  44.         Actualiza la variable MEMtipo
  45.  
  46.     Parámetros:
  47.  
  48.         int tipo: opcion de memoria.
  49.  
  50.     Retorno:
  51.  
  52.         - tipo de memoria
  53.  
  54. ---- CODIGO: -----------------------------------------------------------------*/
  55.  
  56. extern int MEMSeleccionar(int tipo)
  57. {
  58. switch(tipo)
  59.     {
  60.     case OPEMS: MEMTipo = EMS;break;
  61.     case OPXMS: MEMTipo = XMS;break;
  62.     case OPVMS: MEMTipo = VMS;break;
  63.   }
  64. return(MEMTipo);
  65. }
  66.  
  67. /*---- FIN FUNCION -----------------------------------------------------------*/
  68.  
  69.  
  70. /*---- FUNCION: extern IMAGEN *MEMreservarCAB(IMAGEN *c) -----------------------
  71.  
  72.     Descripción:
  73.  
  74.         Esta función reserva memoria convencional para los datos de cabecera
  75.         de una imagen
  76.  
  77.     Parámetros:
  78.  
  79.         IMAGEN *c: Puntero a la imagen.
  80.  
  81.     Retorno:
  82.  
  83.         - Puntero a la imagen reservada
  84.         - Si hubo error, NULL.
  85.  
  86. ---- CODIGO: -----------------------------------------------------------------*/
  87.  
  88. extern IMAGEN *MEMreservarCAB(IMAGEN *c)
  89. {
  90. return(c = (IMAGEN *)malloc(sizeof(IMAGEN)));
  91. }
  92.  
  93. /*---- FIN FUNCION -----------------------------------------------------------*/
  94.  
  95.  
  96. /*---- FUNCION: extern IMAGEN *MEMreservar(IMAGEN *c) --------------------------
  97.  
  98.     Descripción:
  99.  
  100.         Esta función reserva memoria EMS, XMS o VMS para alojar una imagen.
  101.         Los datos de la imagen se encuentran en la estructura apuntada por
  102.         el puntero que se pasa como parámetro.
  103.  
  104.     Parámetros:
  105.  
  106.         IMAGEN *c: Puntero a la cabecera de la imagen.
  107.  
  108.     Retorno:
  109.  
  110.         - Puntero a estructura de la imagen
  111.         - Si no hay memoria, se libera la cabecera y se devuelve NULL
  112.  
  113. ---- CODIGO: -----------------------------------------------------------------*/
  114.  
  115. extern IMAGEN *MEMreservar(IMAGEN *c)
  116. {
  117.     /* contador */
  118. int i;
  119.     /* página y desplazamiento para EMS */
  120. unsigned int pagina=0,despl=0;
  121.     /* tamaño para XMS */
  122. long tam;
  123.  
  124.     /* si es demasiado grande */
  125. if(c->bytes > ANCHO_MAXIMO)
  126.     {
  127.     c=MEMliberar(c);
  128.     return(c);
  129.     }
  130.  
  131.     /* reservar memoria para la imagen */
  132. switch(MEMTipo)
  133.     {
  134.         /* memoria expandida LIM/EMS */
  135.     case EMS:
  136.             /* si está disponible...*/
  137.         if(EMSmemIniciar())
  138.             {
  139.                 /* obtener mrco de página */
  140.             EMSmarco_pagina = EMSMarcoPagina();
  141.                 /* reservar memoria para la tabla de gestión de la memoria EMS */
  142.             if((c->mem.ems.tabla=(unsigned int *)malloc(2*(c->alto)*sizeof(int)))!=NULL)
  143.                 {
  144.                     /* llenar la tabla */
  145.                 for(i=0;i<c->alto;++i)
  146.                     {
  147.                     if(despl+c->bytes >= EMSTamPagina)
  148.                         {
  149.                         pagina++;
  150.                         despl=0;
  151.                         }
  152.                         /* asignar a cada línea una página y su desplazamiento en ella */
  153.                     c->mem.ems.tabla[i*2]=pagina;
  154.                     c->mem.ems.tabla[i*2+1]=despl;
  155.                     despl+=c->bytes;
  156.                     }
  157.                 }
  158.             else
  159.                 {
  160.                 c = MEMliberar(c);
  161.                 return(c);
  162.                 }
  163.                 /* reservar las páginas de memoria requeridas */
  164.             if((c->mem.ems.gestor=EMSmemReservar(pagina+1))==0)
  165.                 c = MEMliberar(c);
  166.             return(c);
  167.             }
  168.         else
  169.             {
  170.             c = MEMliberar(c);
  171.             ERRORponer(ERRnoMemoria);
  172.             return(c);
  173.             }
  174.     break;
  175.  
  176.         /* memoria extendida XMS */
  177.     case XMS:
  178.         c->mem.xms = -1;
  179.             /* calcular Kbytes a reservar */
  180.         tam = (((long)c->bytes * (long)(c->alto))/1024L)+1;
  181.             /* obtener version 2.0 o posterior */
  182.         i = XMSmemIniciar();
  183.             /* si está disponible... reservar */
  184.         if(i >= 0x0200 && i != -1)
  185.             c->mem.xms = XMSmemReservar((int)tam);
  186.             /* si error, liberar */
  187.         if(c->mem.xms == -1)
  188.             {
  189.             c = MEMliberar(c);
  190.             ERRORponer(ERRnoMemoria);
  191.             }
  192.     return(c);
  193.  
  194.         /* memoria virtual VMS */
  195.     case VMS:
  196.             /* calcular tamaño del fichero */
  197.         tam = (long)(c->bytes) * (long)(c->alto);
  198.             /* reservar */
  199.         c->mem.vms = *(VMSmemoria *)VMSmemReservar(tam);
  200.         if(c->mem.vms.gestor == NULL)
  201.             {
  202.             c = MEMliberar(c);
  203.             ERRORponer(ERRnoMemoria);
  204.             }
  205.     return(c);
  206.  
  207.     default:
  208.         c = MEMliberar(c);
  209.     return(c);
  210.     };
  211. }
  212.  
  213. /*---- FIN FUNCION -----------------------------------------------------------*/
  214.  
  215. /*---- FUNCION: extern IMAGEN *MEMliberar(IMAGEN *c) ---------------------------
  216.  
  217.     Descripción:
  218.  
  219.         Esta función libera la memoria convencional apuntada por el puntero
  220.         que se pasa como parámetro, también libera si la hubiese la memoria
  221.         EMS, XMS o VMS reservada para la imagen.
  222.  
  223.     Parámetros:
  224.  
  225.         IMAGEN *c: Puntero a la cabecera de la imagen.
  226.  
  227.     Retorno:
  228.  
  229.         - Puntero a NULL
  230.  
  231. ---- CODIGO: -----------------------------------------------------------------*/
  232.  
  233. extern IMAGEN *MEMliberar(IMAGEN *c)
  234. {
  235. if(c!=NULL)
  236.     {
  237.     switch(MEMTipo)
  238.         {
  239.         case EMS:
  240.                 /* si hay imagen, liberarla */
  241.             if(c->mem.ems.tabla !=NULL)
  242.                 {
  243.                 free(c->mem.ems.tabla);
  244.                 c->mem.ems.tabla=NULL;
  245.                 EMSmemLiberar(c->mem.ems.gestor);
  246.                 }
  247.         break;
  248.             /* si hay imagen, liberarla */
  249.         case XMS:
  250.             if(c->mem.xms != -1)
  251.                 {
  252.                 XMSmemLiberar(c->mem.xms);
  253.                 c->mem.xms = -1;
  254.                 }
  255.         break;
  256.  
  257.             /* si hay imagen, liberarla */
  258.         case VMS:
  259.             if(c->mem.vms.gestor!=NULL)
  260.             VMSmemLiberar(c->mem.vms);
  261.         break;
  262.         }
  263.         /* liberar cabecera */
  264.     free(c);
  265.     c = NULL;
  266.     }
  267. return(c);
  268. }
  269.  
  270. /*---- FIN FUNCION -----------------------------------------------------------*/
  271.  
  272. /*---- FUNCION: extern int MEMleer(char *buffer,int n,IMAGEN *c) ---------------
  273.  
  274.     Descripción:
  275.  
  276.         Esta función copia en un buffer una línea de la imagen desde
  277.         la memoria EMS, XMS o VMS.
  278.  
  279.     Parámetros:
  280.  
  281.         char *buffer: Buffer donde se copiará la línea
  282.         int n: línea a copiar
  283.         IMAGEN *c: Puntero a la imagen.
  284.  
  285.     Retorno:
  286.  
  287.         - 1 si la copió
  288.         - 0 si hubo error
  289.  
  290. ---- CODIGO: -----------------------------------------------------------------*/
  291.  
  292. extern int MEMleer(char *buffer,int n,IMAGEN *c)
  293. {
  294.     /* bloque para mover la memoria XMS */
  295. XMSbloque bloque;
  296.  
  297. switch(MEMTipo)
  298.     {
  299.     case EMS:
  300.             /* mapear a pagina fisica la pagina de la linea n */
  301.         if(!EMSmemMapear(c->mem.ems.gestor,0,c->mem.ems.tabla[n*2]))
  302.             return(0);
  303.             /* copiar la linea en el buffer */
  304.         memcpy(buffer,EMSmarco_pagina+c->mem.ems.tabla[n*2+1],c->bytes);
  305.     return(1);
  306.  
  307.     case XMS:
  308.             /* mover el bloque */
  309.         bloque.longitud = (long)c->bytes;
  310.         bloque.fuente = c->mem.xms;
  311.         bloque.desp_fuente = (long)n * (long)c->bytes;
  312.         bloque.destino = 0;
  313.         bloque.desp_destino = PunteroALong(buffer);
  314.         if(!XMSmemMover(&bloque))
  315.             return(0);
  316.     break;
  317.  
  318.     case VMS:
  319.             /* posicionar y leer del fichero */
  320.         fseek(c->mem.vms.gestor,(long)n*(long)(c->bytes),SEEK_SET);
  321.         fread(buffer,c->bytes,1,c->mem.vms.gestor);
  322.     break;
  323.     }
  324. return(1);
  325. }
  326.  
  327. /*---- FIN FUNCION -----------------------------------------------------------*/
  328.  
  329. /*---- FUNCION: extern int MEMescribir(char *buffer,int n,IMAGEN *c) -----------
  330.  
  331.     Descripción:
  332.  
  333.         Esta función copia desde un buffer una línea de la imagen a
  334.         la memoria EMS, XMS o VMS.
  335.  
  336.     Parámetros:
  337.  
  338.         char *buffer: Buffer donde se encuentra la línea
  339.         int n: línea a copiar
  340.         IMAGEN *c: Puntero a la imagen.
  341.  
  342.     Retorno:
  343.  
  344.         - 1 si la copió
  345.         - 0 si hubo error
  346.  
  347. ---- CODIGO: -----------------------------------------------------------------*/
  348.  
  349. extern int MEMescribir(char *buffer,int n,IMAGEN *c)
  350. {
  351.     /* bloque para mover la memoria XMS */
  352. XMSbloque bloque;
  353.  
  354. switch(MEMTipo)
  355.     {
  356.     case EMS:
  357.             /* mapear a pagina fisica la pagina de la linea n */
  358.         if(!EMSmemMapear(c->mem.ems.gestor,0,c->mem.ems.tabla[n*2]))
  359.             return(0);
  360.             /* copiar el buffer en la linea n */
  361.         memcpy(EMSmarco_pagina+c->mem.ems.tabla[n*2+1],buffer,c->bytes);
  362.     break;
  363.     case XMS:
  364.             /* mover bloque */
  365.         bloque.longitud = (long)c->bytes;
  366.         bloque.fuente = 0;
  367.         bloque.desp_fuente = PunteroALong(buffer);
  368.         bloque.destino = c->mem.xms;
  369.         bloque.desp_destino = (long)n * (long)c->bytes;
  370.     if(!XMSmemMover(&bloque))
  371.         return(0);
  372.     else
  373.         return(1);
  374.     break;
  375.     case VMS:
  376.             /* posicionar y escribir en el fichero */
  377.         if(!fseek(c->mem.vms.gestor,(long)n*(long)(c->bytes),SEEK_SET))
  378.             {
  379.             fwrite(buffer,c->bytes,1,c->mem.vms.gestor);
  380.             return(1);
  381.             }
  382.         else
  383.             return(0);
  384.     break;
  385.     }
  386. return(0);
  387. }
  388.  
  389. /*---- FIN FUNCION -----------------------------------------------------------*/
  390.